/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package kn.cstf2.users.Server;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import kn.cstf2.global.db.Operations.OperacionesDB;
import org.apache.log4j.Logger;
import kn.cstf2.global.Utils.CstF2Exception;
import kn.cstf2.users.Bean.UserBean;
import kn.cstf2.users.Bean.UsersBean;
import kn.cstf2.users.Sql.UsersSql;
/**
 *
 * @author user1
 */
public class UsersServer {
    private static Logger log = Logger.getLogger(UsersServer.class);
    OperacionesDB odb = new OperacionesDB();
    
    
    
  public ArrayList<String>  ObternerUsersWithSameNameAndEmail(String name, String email) {
        
        ArrayList<String> users = new ArrayList<String>();    
        
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sentenciaSQL = UsersSql.SELECCIONAR_USERS_SAMENAME_SAMEEMAIL;
        int index = 1;
        
        try {
            conn = odb.obtenerConexion("db");
            ps = conn.prepareStatement(sentenciaSQL);
            ps.setString(index++, name);
            ps.setString(index++, email);

            rs = ps.executeQuery();
            users = AdaptadorUsers.ObternerUsersWithSameNameAndEmail(rs);         
        } catch (SQLException ex) {
            log.error("Error al obtener el Usuario desde la base de datos", ex);
            throw new CstF2Exception("Error al obtener el Usuario desde la base de datos");
        } finally {
            odb.cerrarResultSet(rs);
            odb.cerrarStatement(ps);
            odb.cerrarConnection(conn);
        }
        return users;
  }
    
    
    
  public ArrayList<UsersBean>  ObternerUsersByName(String name) {
        
        ArrayList<UsersBean> users = new ArrayList<UsersBean>();    
        UsersBean userBean = new UsersBean();
        
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sentenciaSQL = UsersSql.SELECCIONAR_USERS_BYNAME;
        int index = 1;
        
        try {
            conn = odb.obtenerConexion("db");
            ps = conn.prepareStatement(sentenciaSQL);
            ps.setString(index++, "%"+name+"%");
            
            rs = ps.executeQuery();
            users = AdaptadorUsers.ObternerUsersByName(rs);         
        } catch (SQLException ex) {
            log.error("Error al obtener el Usuario desde la base de datos", ex);
            throw new CstF2Exception("Error al obtener el Usuario desde la base de datos");
        } finally {
            odb.cerrarResultSet(rs);
            odb.cerrarStatement(ps);
            odb.cerrarConnection(conn);
        }
        return users;
  }
  
    public ArrayList<StringBuilder>  ObternerModificarUsersByName(String name) {
        
        ArrayList<StringBuilder> users = new ArrayList<StringBuilder>();    

        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sentenciaSQL = UsersSql.SELECCIONAR_USERS_BYNAME;
        int index = 1;
        
        try {
            conn = odb.obtenerConexion("db");
            ps = conn.prepareStatement(sentenciaSQL);
            ps.setString(index++, "%"+name+"%");
            
            rs = ps.executeQuery();
            users = AdaptadorUsers.ObtenerModificarUsersByName(rs);         
        } catch (SQLException ex) {
            log.error("Error al obtener el Usuario desde la base de datos", ex);
            throw new CstF2Exception("Error al obtener el Usuario desde la base de datos");
        } finally {
            odb.cerrarResultSet(rs);
            odb.cerrarStatement(ps);
            odb.cerrarConnection(conn);
        }
        return users;
  }
    
    
    
  public UsersBean  ObternerUsersInfo(Integer idUser) {
        
       UsersBean userBean = new UsersBean();
         
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sentenciaSQL = UsersSql.SELECCIONAR_USERS_INFO;
        int index = 1;
        
        try {
            conn = odb.obtenerConexion("db");
            ps = conn.prepareStatement(sentenciaSQL);
            ps.setInt(index++, idUser);

            rs = ps.executeQuery();
            userBean = AdaptadorUsers.ObternerUsersInfo(rs);         
        } catch (SQLException ex) {
            log.error("Error al obtener el Usuario desde la base de datos", ex);
            throw new CstF2Exception("Error al obtener el Usuario desde la base de datos");
        } finally {
            odb.cerrarResultSet(rs);
            odb.cerrarStatement(ps);
            odb.cerrarConnection(conn);
        }
        return userBean;
  }
  
  public void  ActualizarUserDataByBean(UsersBean usersBean) {
        
        ArrayList<String> users = new ArrayList<String>();    
         
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sentenciaSQL = UsersSql.ACTUALIZA_DATOS_USUARIO_BYBEAN;
        int index = 1;
        
        try {
            conn = odb.obtenerConexion("db");
            ps = conn.prepareStatement(sentenciaSQL);
            ps.setString(index++, usersBean.getUsername());
            ps.setString(index++, usersBean.getPwd());
            ps.setString(index++, usersBean.getEmail());
            ps.setString(index++, usersBean.getUsertype());           
            ps.setBoolean(index++, usersBean.getRg());
            ps.setBoolean(index++, usersBean.getRgro());
            ps.setBoolean(index++, usersBean.getRco());
            ps.setBoolean(index++, usersBean.getRcoro());
            ps.setBoolean(index++, usersBean.getCcr());
            ps.setBoolean(index++, usersBean.getCcrro());
            ps.setBoolean(index++, usersBean.getOpc());
            ps.setBoolean(index++, usersBean.getOpcro());
            ps.setBoolean(index++, usersBean.getMng());
            ps.setBoolean(index++, usersBean.getMngro());
            ps.setBoolean(index++, usersBean.getSu());
            
            ps.setInt(index++, usersBean.getId());

            ps.executeUpdate();
            //users = AdaptadorUsers.ObternerUsersWithSameNameAndEmail(rs);         
        } catch (SQLException ex) {
            log.error("Error al obtener el Usuario desde la base de datos", ex);
            throw new CstF2Exception("Error al obtener el Usuario desde la base de datos");
        } finally {
            odb.cerrarResultSet(rs);
            odb.cerrarStatement(ps);
            odb.cerrarConnection(conn);
        }
        
  }
    
    
    
  public void  BorrarUserClientDependences(Integer idUserSelected) {
        
        ArrayList<String> users = new ArrayList<String>();    
         
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sentenciaSQL = UsersSql.BORRA_DEPENDENCIAS_ALUSUARIO;
        int index = 1;
        
        try {
            conn = odb.obtenerConexion("db");
            ps = conn.prepareStatement(sentenciaSQL);
            ps.setInt(1, idUserSelected);


            ps.execute();
            //users = AdaptadorUsers.ObternerUsersWithSameNameAndEmail(rs);         
        } catch (SQLException ex) {
            log.error("Error al obtener el Usuario desde la base de datos", ex);
            throw new CstF2Exception("Error al obtener el Usuario desde la base de datos");
        } finally {
            odb.cerrarResultSet(rs);
            odb.cerrarStatement(ps);
            odb.cerrarConnection(conn);
        }
        
  }
    
    
    
  public void  BorrarUserClient(Integer idUserSelected) {
        
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sentenciaSQL = UsersSql.BORRA_ALUSUARIO;
        int index = 1;
        
        try {
            conn = odb.obtenerConexion("db");
            ps = conn.prepareStatement(sentenciaSQL);
            ps.setInt(1, idUserSelected);


            ps.execute();
            //users = AdaptadorUsers.ObternerUsersWithSameNameAndEmail(rs);         
        } catch (SQLException ex) {
            log.error("Error al obtener el Usuario desde la base de datos", ex);
            throw new CstF2Exception("Error al obtener el Usuario desde la base de datos");
        } finally {
            odb.cerrarResultSet(rs);
            odb.cerrarStatement(ps);
            odb.cerrarConnection(conn);
        }
        
  }
    
    
    
  public void  GuardaNewUser(UsersBean userBean) {
      
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sentenciaSQL = UsersSql.GUARDA_NUEVO_USUARIO;
        int index = 1;
        
        try {
            conn = odb.obtenerConexion("db");
            ps = conn.prepareStatement(sentenciaSQL);
            ps.setString(index++, userBean.getUsername());
            ps.setString(index++, userBean.getPwd());
            ps.setString(index++, userBean.getEmail());
            ps.setString(index++, userBean.getUsertype());
            ps.setBoolean(index++, userBean.getRg());
            ps.setBoolean(index++, userBean.getRgro());
            ps.setBoolean(index++, userBean.getRco());
            ps.setBoolean(index++, userBean.getRcoro());
            ps.setBoolean(index++, userBean.getCcr());
            ps.setBoolean(index++, userBean.getCcrro());
            ps.setBoolean(index++, userBean.getOpc());
            ps.setBoolean(index++, userBean.getOpcro());
            ps.setBoolean(index++, userBean.getMng());
            ps.setBoolean(index++, userBean.getMngro());
            ps.setBoolean(index++, userBean.getSu());

            ps.execute();
            //users = AdaptadorUsers.ObternerUsersWithSameNameAndEmail(rs);         
        } catch (SQLException ex) {
            log.error("Error al obtener el Usuario desde la base de datos", ex);
            throw new CstF2Exception("Error al obtener el Usuario desde la base de datos");
        } finally {
            odb.cerrarResultSet(rs);
            odb.cerrarStatement(ps);
            odb.cerrarConnection(conn);
        }
  }

    public void  SaveNewUser(UserBean userBean) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sentenciaSQL = UsersSql.SAVE_NUEVO_USUARIO;
        int index = 1;
        
        try {
            conn = odb.obtenerConexion("db");
            ps = conn.prepareStatement(sentenciaSQL);
            ps.setString(index++, userBean.getUsername());
            ps.setString(index++, userBean.getPwd());
            ps.setString(index++, userBean.getEmail());
            ps.setBoolean(index++, userBean.getSu());
            ps.setBoolean(index++, userBean.getTransition());
            ps.setBoolean(index++, userBean.getTransitionAccess());
            ps.setBoolean(index++, userBean.getImplementation());
            ps.setBoolean(index++, userBean.getImplementationAccess());
            ps.setBoolean(index++, userBean.getCop());
            ps.setBoolean(index++, userBean.getCopAccess());

            ps.executeUpdate();
            //users = AdaptadorUsers.ObternerUsersWithSameNameAndEmail(rs);         
        } catch (SQLException ex) {
            log.error("Error al obtener el Usuario desde la base de datos", ex);
            throw new CstF2Exception("Error al obtener el Usuario desde la base de datos");
        } finally {
            odb.cerrarResultSet(rs);
            odb.cerrarStatement(ps);
            odb.cerrarConnection(conn);
        }
    } 

    public void modifyUser(UserBean userBean) {
        Connection conn = null;
        PreparedStatement ps = null;
        ResultSet rs = null;
        String sentenciaSQL = UsersSql.MODIFICAR_USUARIO;
        int index = 1;
        
        try {
            conn = odb.obtenerConexion("db");
            ps = conn.prepareStatement(sentenciaSQL);
            ps.setString(index++, userBean.getUsername());
            ps.setString(index++, userBean.getPwd());
            ps.setString(index++, userBean.getEmail());
            ps.setBoolean(index++, userBean.getSu());
            ps.setBoolean(index++, userBean.getTransition());
            ps.setBoolean(index++, userBean.getTransitionAccess());
            ps.setBoolean(index++, userBean.getImplementation());
            ps.setBoolean(index++, userBean.getImplementationAccess());
            ps.setBoolean(index++, userBean.getCop());
            ps.setBoolean(index++, userBean.getCopAccess());
            ps.setInt(index++, userBean.getId());

            ps.executeUpdate();      
        } catch (SQLException ex) {
            log.error("Error al obtener el Usuario desde la base de datos", ex);
            throw new CstF2Exception("Error al obtener el Usuario desde la base de datos");
        } finally {
            odb.cerrarResultSet(rs);
            odb.cerrarStatement(ps);
            odb.cerrarConnection(conn);
        }
    }
}
